SPACE 2/SPACE - Library 2 - Volume 1.iso/apps/82/tutorc.eng

Text File | 1986-11-20 | 8KB | 155 lines

0660103030566
9[....................................................]

                       üC,THELANGUAGE

     WÇelcometothisfirstlessoninüCÇlanguage.Thisseriesof
articlesismeantasalearningmethodforbeginningprogrammers
inüCÇ.Iwillhowevertakeforgrantedthatthereaderalreadyhas
somenotionssuchasknowledgeofloops,conditionnalexpressions,
etc.

     Hereisthefirstwarning.TheüCÇlanguageisnotaneasy
language.Itisaflexiblelanguage,generatingfastandcompact
codebutitisveryhardtodebug.Errormessages,whenthereare
any(...),arenotextremelysignificantandmayreferto
correctlywritteninstructions(therealerrormightinfactbe
anywhere...).

     Asecondwarning.TheexistingversionsofüCÇavailableonthe
üSTÇarecompiledlanguages.Thismeansthattheyarenotdirectly
executablelikeüSTBasicÇorüAtariLOGOÇ.(Thoseareinterpreted
languages).Youcannot,forexample,typealineofcodeandsee
(orobserve)itseffectimmediately.Manystepsarenecessary
beforeyouobtainareadytorunprogram.Tofindtherightsteps,
toexecutetheminorder,willtakemoretimeduringthefirst
triesthanwritingtheprogramitself.

     Ifthisintroductionhasn'tdiscouragedyou,youareready
foryourfirstplunge.

     First,youneedaprogrameditor.Manyofthemareavailable
onthemarket:üMinceÇorüMicro-EmacsÇ,orsimpler;awordprocessing
programsuchasü1st-WordÇ.Withthelatter,youmustbecarefulnot
toselecttheWPmode,becauseitwillinsertinthetextsome
controlcharactersthatwillnotberecognizedbythecompiler.

     Typethefollowinglines:

#üinclude"osbind.h"

main()Ç
{ü
Cconws("ThisismyfirstCprogram");
Cconin();
Ç}


     Savethistextfileunderthename"üMYFIRST.CÇ"

     Let'snowanalysethisprogramindetail.Thefirstline,
#üincludeÇ"üosbind.hÇ",containsthe#character.Thissymbolsignals
tothecompilerthearrivalofapre-processorcommand.Itmustbe
usedonlyinthismanner(unlessitappearsinasentencebetween
quotes).TheüincludeÇpre-processorcommandincludestheüosbind.hÇ
fileinsidethecode.Thisfilecontainsdefinitionsforthe
üCconwsÇandüCconinÇofourprogramand,inamoregeneralway,it
containsthedefinitionsoftheüCPM-68KÇoperatingsystem.This
typeoffilewhichcontainsdefinitions,ischaracterizedbyits
ü.hÇextension.Forexample,theüvdibind.hÇandüaesbind.hÇfilesare
definitionsfortheüVDIÇandüAESÇ;theyareentrypointstotheüGEMÇ.
Noticethatthenameofthefilemustbebetweenquotes.

     Thesecondline,ümain()Ç,tellsthecompilerthattheprogram
executionmustbeginhere.Theümain()Çfunctionmayinfactbe
anywhereinsidethetext.InüCÇ,exceptionmadeofthepre-
processorcommands,onlyfunctionsexist.Functionswhichcall
otherfunctionswhichcallyetmorefunctions,etc...Thefirst
functiontobeexecutedisalwaysümain()Çevenifitisnotthe
firstonetoappearinthetext.

     Afunctionisdistinguishablebythepresenceofparenthesis
whichalwaysfollowthenameofthefunction.Theseparenthesis
containtheargument(s)ofthefunction.Theümain()Çfunctiontakes
noargumentsso,the(compulsary)parenthesisareempty.The
üCconwsÇfunctioncontainsanargument,thesentence:"üThisismy
firstCprogramÇ",thisfunctionwillwritethelineoftextonthe
screenatthecurrentcursorlocation,here,theupperleft
corner.(üCconswÇistheabbreviationfor'üConsolewritestringÇ'.)
Thequotesdelimitingthesentencearenecessaryaswellasthe
semicolonendingthelineüCconsw(Ç"üThisismyfirstCprogramÇ"ü);
ÇTheabsenceofthispunctuationwillreturnanerrormessage
duringcompilation.

     Thesemicoloniswhatiscalled,inprogrammer'sslang,a
delimiter.Itspecifiesthateverythingprecedingitalltheway
backtotheprevioussemicolonorbacktothestartofthe
functionproper,isafunctionthatiscompletebyitself.The
semicolondelimitatesthebodyoftheprecedingfunction.

     Thefollowingfunction,üCconin();Çwaitsforsomecharacterto
betypedonthekeyboardanddisplaysitonthescreen(ifitisa
printableASCIIcharacter).üCconinÇistheabbreviationfor
'üConsoleInputÇ'.Thereisanotherfunctionthatdoesthesamejob,
butwithoutprintingthecharacter;itsnameisüCnecin()Ç.Thisone
mustbeusedduringapauseinsideaprogram,forexample.

     Onthelastlinewefindaclosingbracket'ü}Ç',whichis
alwayspairedtoanopeningbracket'ü{Ç'.Theyareusedtolimit
thefieldoftheümain()Çfunction,'ü{Ç'markingthestartand'ü}Ç'at
theend.TheyareusedinthesamemannerintestsusingüwhileÇor
üifÇ-üthenÇ-üelseÇaswewillseelater.

     Allthatisleftforustodonowisto"compile"this
program.Thecompilationistheprocessbywhichthecomputer
translatestheprogramtextinbinaryinstructions(i.e.machine
language)andplacestheseinstructionsinafilewithaü.PRGÇ
suffix.Thisfileisdirectlyexecutable,meaningthatitdoesn't
needanotherprogramtorunit,(forexampletakeaüLOGOÇprogram
whichneedstheüLOGO.PRGÇfiletowork).

     Thecompilationstepsneededvaryfromonecompilerto
another.ForthecompilerthatcomeswiththeüAtariÇüToolkitÇ,the
stepstofolloware:

üCP68KMYFIRST.CMYFIRST.I
ÇüC068MYFIRST.IMYFIRST.1MYFIRST.2MYFIRST.3-F
C168MYFIRST.1MYFIRST.2MYFIRST.S
AS68-L-UMYFIRST.S
Ç
üLINK68[U]MYFIRST.68K=APSTART,MYFIRST,GEMLIB
RELMODMYFIRST
Ç
     ThefirstfourstepsproducethefileüMYFIRST.SÇ,üÇwhichisan
assemblylanguagefile(accordingtoüMotorolaÇmnemoniccodes).The
twolaststepswillgeneratethedesiredfile,üMYFIRST.PRGÇ.

ü     ÇThenamesatthestartofeachofthefirstfourlinesabove
correspondtothenamesoffilesonthe"üCompilerDiskÇ"andthe
lasttwocorrespondtonamesoffilesonthe"üLinkerDiskÇ".You
mustexecutetheseprogramsbyenteringtheparametersthatfollow
thenameinthelineinthefollowingmanner:'click'onceonthe
nameoftheprogram,selectüInstallApplicationÇintheüOPTION
Çchoice(menubar)ü,Çandwriteintherequiredparameters.

     AsecondmethodconsistsincallingtheüCOMMAND.PRGÇprogram
(itisincludedineachofthediskettesmentionned)andwritein
thelinesasabove.

     Athirdmethod,theonemostoftenused,callsfortheü.BATÇ
filemethod.Thesefilescontaintheequivalentofthelines
above.Forexample,theüC.BATÇfilecontainsthefirstfourlines
above;weexecutethisfilebycallingtheüBATCH.PRGÇandbytyping
üC.MYFIRSTÇ(andnotüC.BATMYFIRST.CÇasmighthavebeenexpected).
Forthetwolastlines,calltheüBATCH.PRGÇwiththeparameters
üLINKCMYFIRSTÇ(thisone'snamewillvaryaccordingtoyourversion
oftheüTOOLKITÇ).

     Whenyouhavefinished,yourfirstprogramwillappearunder
thenameüMYFIRST.PRGÇ.Tryit...Inthenextlesson,wewill
examinehowtouseloopsandconditionnalexpressions.

üAlainBirtz
March1986Ç